home *** CD-ROM | disk | FTP | other *** search
/ Aminet 28 / Aminet 28 (1998)(GTI - Schatztruhe)[!][Dec 1998].iso / Aminet / dev / lang / fpc09905c.lha / fpc / units / strings.pp < prev    next >
Text File  |  1998-09-21  |  20KB  |  644 lines
  1. {
  2.     $Id: strings.pp,v 1.2 1998/07/01 14:29:42 carl Exp $
  3.     This file is part of the Free Pascal run time library.
  4.     Copyright (c) 1997 by Carl-Eric Codere,
  5.     member of the Free Pascal development team.
  6.  
  7.     See the file COPYING.FPC, included in this distribution,
  8.     for details about the copyright.
  9.  
  10.     This program is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13.  
  14.  **********************************************************************}
  15. Unit Strings;
  16.  
  17.  
  18.   {*********************************************************************}
  19.   { Strings unit, 100% portable.                                        }
  20.   {- COMPILING INFORMATION ---------------------------------------------}
  21.   {   The only difference between this  unit and the one supplied with  }
  22.   {   Turbo Pascal 7.01, are that StrLen returns a longint, and the     }
  23.   {   routines requiring a length now use longints instead of words.    }
  24.   {   This should not influence the behaviour of your programs under    }
  25.   {   Turbo Pascal. (it will even create better error checking for your }
  26.   {   programs).                                                        }
  27.   {*********************************************************************}
  28.  
  29.  Interface
  30.  {*********************************************************************}
  31.  { Returns the number of Characters in Str,not counting the Null       }
  32.  { chracter.                                                           }
  33.  {*********************************************************************}
  34.  
  35. function StrLen(Str: PChar): longint;
  36.  
  37.  
  38. function StrEnd(Str: PChar): PChar;
  39.  
  40.   {*********************************************************************}
  41.   {  Description: Move count characters from source to dest.            }
  42.   {   Do not forget to use StrLen(source)+1 as l parameter to also move }
  43.   {   the null character.                                               }
  44.   {  Return value: Dest                                                 }
  45.   {   Remarks: Source and Dest may overlap.                             }
  46.   {*********************************************************************}
  47.  
  48. function StrMove(Dest,Source : Pchar;l : Longint) : pchar;
  49.  
  50.  
  51. function StrCopy(Dest, Source: PChar): PChar;
  52.  
  53.  {*********************************************************************}
  54.  {  Input: Source -> Source of the null-terminated string to copy.     }
  55.  {         Dest   -> Destination of null terminated string to copy.    }
  56.  {    Return Value: Pointer to the end of the copied string of Dest.   }
  57.  {  Output: Dest ->   Pointer to the copied string.                    }
  58.  {*********************************************************************}
  59. function StrECopy(Dest, Source: PChar): PChar;
  60.  
  61.   {*********************************************************************}
  62.   {  Copies at most MaxLen characters from Source to Dest.              }
  63.   {                                                                     }
  64.   {   Remarks: According to the Turbo Pascal programmer's Reference     }
  65.   {    this routine performs length checking. From the code of the      }
  66.   {    original strings unit, this does not seem true...                }
  67.   {   Furthermore, copying a null string gives two null characters in   }
  68.   {   the destination according to the Turbo Pascal routine.            }
  69.   {*********************************************************************}
  70.  
  71. function StrLCopy(Dest, Source: PChar; MaxLen: Longint): PChar;
  72.  
  73.  {*********************************************************************}
  74.  {  Input: Source -> Source of the pascal style string to copy.        }
  75.  {         Dest   -> Destination of null terminated string to copy.    }
  76.  {    Return Value: Dest. (with noew copied string)                    }
  77.  {*********************************************************************}
  78.  
  79. function StrPCopy(Dest: PChar; Source: String): PChar;
  80.  
  81.  {*********************************************************************}
  82.  {  Description: Appends a copy of Source to then end of Dest and      }
  83.  {               return Dest.                                          }
  84.  {*********************************************************************}
  85.  
  86. function StrCat(Dest, Source: PChar): PChar;
  87.  
  88.  {*********************************************************************}
  89.  { Description: Appends at most MaxLen - StrLen(Dest) characters from  }
  90.  { Source to the end of Dest, and returns Dest.                        }
  91.  {*********************************************************************}
  92.  
  93.       function strlcat(dest,source : pchar;l : Longint) : pchar;
  94.  
  95.   {*********************************************************************}
  96.   {  Compares two strings. Does the ASCII value substraction of the     }
  97.   {  first non matching characters                                      }
  98.   {   Returns 0 if both strings are equal                               }
  99.   {   Returns < 0 if Str1 < Str2                                        }
  100.   {   Returns > 0 if Str1 > Str2                                        }
  101.   {*********************************************************************}
  102.  
  103. function StrComp(Str1, Str2: PChar): Integer;
  104.  
  105.   {*********************************************************************}
  106.   {  Compares two strings without case sensitivity. See StrComp for more}
  107.   {  information.                                                       }
  108.   {   Returns 0 if both strings are equal                               }
  109.   {   Returns < 0 if Str1 < Str2                                        }
  110.   {   Returns > 0 if Str1 > Str2                                        }
  111.   {*********************************************************************}
  112.  
  113. function StrIComp(Str1, Str2: PChar): Integer;
  114.  
  115.   {*********************************************************************}
  116.   {  Compares two strings up to a maximum of MaxLen characters.         }
  117.   {                                                                     }
  118.   {   Returns 0 if both strings are equal                               }
  119.   {   Returns < 0 if Str1 < Str2                                        }
  120.   {   Returns > 0 if Str1 > Str2                                        }
  121.   {*********************************************************************}
  122.  
  123. function StrLComp(Str1, Str2: PChar; MaxLen: Longint): Integer;
  124.  
  125.   {*********************************************************************}
  126.   {  Compares two strings up to a maximum of MaxLen characters.         }
  127.   {  The comparison is case insensitive.                                }
  128.   {   Returns 0 if both strings are equal                               }
  129.   {   Returns < 0 if Str1 < Str2                                        }
  130.   {   Returns > 0 if Str1 > Str2                                        }
  131.   {*********************************************************************}
  132.  
  133. function StrLIComp(Str1, Str2: PChar; MaxLen: Longint): Integer;
  134.  
  135.  {*********************************************************************}
  136.  {  Input: Str  -> String to search.                                   }
  137.  {         Ch   -> Character to find in Str.                           }
  138.  {  Return Value: Pointer to first occurence of Ch in Str, nil if      }
  139.  {                not found.                                           }
  140.  {  Remark: The null terminator is considered being part of the string }
  141.  {*********************************************************************}
  142.  
  143. function StrScan(Str: PChar; Ch: Char): PChar;
  144.  
  145.  {*********************************************************************}
  146.  {  Input: Str  -> String to search.                                   }
  147.  {         Ch   -> Character to find in Str.                           }
  148.  {  Return Value: Pointer to last occurence of Ch in Str, nil if       }
  149.  {                not found.                                           }
  150.  {  Remark: The null terminator is considered being part of the string }
  151.  {*********************************************************************}
  152.  
  153.  
  154. function StrRScan(Str: PChar; Ch: Char): PChar;
  155.  
  156.  {*********************************************************************}
  157.  {  Input: Str1